Switchable on-die memory error correcting engine

ABSTRACT

Subject matter disclosed herein relates to a user-switchable error correction coding (ECC) engine residing on a memory die.

REFERENCE TO RELATED APPLICATIONS

This application is a continuation of U.S. patent application Ser. No. 13/946,492, filed Jul. 19, 2013, entitled SWITCHABLE ON-DIE MEMORY ERROR CORRECTING ENGINE, which is a continuation of U.S. patent application Ser. No. 12/495,081, filed Jun. 30, 2009, now U.S. Pat. No. 8,495,467, entitled SWITCHABLE ON-DIE MEMORY ERROR CORRECTING ENGINE, each of which is hereby incorporated by reference in its entirety and made part of this specification.

BACKGROUND

1. Field

Subject matter disclosed herein relates to a user-switchable error correction coding (ECC) engine residing on a memory die.

2. Information

Memory systems are employed in many types of electronic devices, such as computers, cell phones, PDA's, data loggers, and navigational equipment, just to name a few examples. Among such electronic devices, various types of nonvolatile memory systems may be employed, such as NAND or NOR flash memories, SRAM, DRAM, and phase-change memory, just to name a few examples. In general, writing or programming processes may be used to store information in such memory systems, while a read process may be used to retrieve stored information.

Such nonvolatile memory systems may comprise memory cells that slowly deteriorate over time, leading to an increasing probability that a read and/or write error may occur upon accessing such a memory cell. Accordingly, an error correction process may be employed to correct such errors as they occur. For example, an error correction coding (ECC) engine may be employed in a memory system in order to correct errors generated in the memory system. Typically, such an ECC engine may be limited in its ability to correct errors. If a number of errors occurs beyond such a capability, then an ECC engine may itself produce errors, thereby adding to the number of errors generated by the memory system.

BRIEF DESCRIPTION OF THE FIGURES

Non-limiting and non-exhaustive embodiments will be described with reference to the following figures, wherein like reference numerals refer to like parts throughout the various figures unless otherwise specified.

FIG. 1 is a schematic block diagram of a portion of a computing system, according to an embodiment.

FIG. 2 is a schematic block diagram of a portion of a memory system, according to an embodiment.

FIG. 3 is a schematic block diagram of a system and one or more aspects of a memory configuration, according to an embodiment.

FIG. 4 is a flow diagram illustrating a read process, according to an embodiment.

FIG. 5 is a schematic block diagram illustrating a computing system and a memory system, according to an embodiment.

DETAILED DESCRIPTION

Reference throughout this specification to “one embodiment” or “an embodiment” means that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment of claimed subject matter. Thus, the appearances of the phrase “in one embodiment” or “an embodiment” in various places throughout this specification are not necessarily all referring to the same embodiment. Furthermore, the particular features, structures, or characteristics may be combined in one or more embodiments.

In an embodiment, operation of an error correction code (ECC) decoder, or ECC engine, residing on a memory die, hereinafter referred to as an on-die ECC engine, may be switched on or off by a host computing system that incorporates a memory system comprising one or more such memory die. As described in detail below, such memory die may comprise a discrete semiconductor chip that is a portion of individual memory modules that collectively make up a larger memory system, for example. A system-level ECC engine, that is, an ECC engine deployed external to a memory die, for example, may be used in place of a disabled on-die ECC engine to correct read errors. Such a system-level ECC engine may provide an error correction capability beyond that of an on-die ECC engine. In a particular implementation, for example, such a system-level ECC engine may function across multiple memory die, thereby providing error correction for signals representative of data read from the multiple memory die. In such a case, it may be particularly desirable to switch off the on-die ECC engine residing on the individual memory die, since such on-die ECC engines may themselves generate errors and/or add a delay to a read process. For example, if an on-die ECC engine is presented with a number of errors beyond the ECC engine's capability to correct, then the ECC engine may introduce additional errors instead of eliminate errors. Accordingly, switching off or otherwise disabling an on-die ECC engine may prevent introduction of such additional errors as well as avoid delay resulting from operation of the on-die ECC engine. In one particular implementation, a system-level ECC engine and an on-die ECC engine may be enabled or disabled on-the-fly during read/write processes from/to a memory system. In another particular implementation, a system-level ECC engine and an on-die ECC engine may be enabled or disabled during a system configuration process, such as a memory drive format operation, for example. Of course, such details of an ECC engine are merely examples, and claimed subject matter is not so limited.

Embodiments, such as those described below, may involve a memory system comprising a phase-change memory (PCM) device. As a PCM ages, a bit error rate and/or a number of bit errors produced by portions of the PCM may increase. Such errors, to some extent, may be corrected using an on-die ECC engine and/or other such error correcting algorithms, for example. However, a number of errors may increase beyond a capability of such an on-die ECC engine to correct. Therefore, at some point during a lifetime of a memory device, it may be desirable to employ a system-level ECC engine, as described in detail below.

In an embodiment, a memory system using an external ECC engine applied across one or more die may provide a benefit of combining error probabilities of such die so that a number or errors per code word may remain below a threshold. For example, errors from multiple die may be combined in such a way that although there may be an error on multiple data transactions, a number of errors per code word, to which a correction process is applied, may be more probable to remain below a threshold of an ECC engine that corrects less bits externally than would be required to obtain the same result if an ECC engine were in a die. In other words, it may be easier to use one 3-bit ECC at a system level that is able to handle bits of many die than it is to obtain the same results by finding an appropriate equivalent ECC corrector inside a die. In addition, an external corrector may be relatively easy to swap out for a larger corrector (e.g., a 6-bit ECC), if so desired.

FIG. 1 is a schematic block diagram illustrating a portion of a computing system 100, according to an embodiment. A processor 110 may process executable instructions to read/write signals representative of information from/to a memory system 120 via a memory controller 130. In a particular implementation, memory controller 130 may manage a flow of information between processor 110 and one or more memory modules 140. For example, memory controller 130 may manage read and/or write processes in response to instructions from processor 110. Memory controller 130 may be integrated with processor 110 or memory system 120, as indicated in FIG. 1, or may comprise a discrete semiconductor chip, for example. Memory system 120 may comprise a solid-state drive (SSD) memory that includes multiple memory modules 140 functionally arranged parallel with one another, for example. According to a particular embodiment, one or more portions of memory system 120 may store signals representative of data and/or information as expressed by a particular state of memory system 120. For example, an electronic signal representative of data and/or information may be “stored” in a portion of memory system by affecting or changing the state of such portions of memory system 120 to represent data and/or information as binary information (e.g., ones and zeros). As such, in a particular implementation, such a change of state of the portion of memory to store a signal representative of data and/or information constitutes a transformation of memory system 120 to a different state or thing. Of course, details of such a computing system are merely examples, and claimed subject matter is not so limited.

FIG. 2 is a schematic block diagram illustrating a portion of a memory system 200, according to an embodiment. Such a portion may comprise memory module 140 shown in FIG. 1, for example. Memory system 200 may include die array 210 comprising one or more memory die 230 functionally arranged parallel with one another. Such a parallel arrangement may result in faster read/write speed compared with serially arranged memory die, for example. Memory system 200, however, is not limited to such a parallel arrangement. Memory die may be serially arranged by incorporating a capability to buffer read/write data as needed, for example.

Individual memory die 230 may include an on-die ECC engine 240 to correct read errors generated by the individual memory die. As discussed above, such an on-die ECC engine 240 may be switched on or off according to instructions from outside memory portion 200, for example. In one particular implementation, a subsystem-level ECC engine 220, which may comprise a separate device, may be employed if, for example, on-die ECC engine 240 is switched off or otherwise disabled. Here, the term subsystem indicates that such a subsystem-level ECC engine 220 may reside external to die array 210, whereas a system-level ECC engine, discussed below, may reside external to memory system 120, shown in FIG. 1, for example. In another particular implementation, subsystem-level ECC engine 220 may be employed to provide subsystem-level error correction across multiple memory die 230. Such subsystem-level error correction may involve improved performance compared to error correction employed at a memory die level, such as by on-die ECC engine 240, for example. Here, performance may be measured in terms of capability to correct errors, delay, flexibility of applying such error correction, and/or time/latency involved with correcting errors. If subsystem-level ECC engine 220 is employed, then it may be desirable to switch off or otherwise disable on-die ECC engine 240 residing on individual memory die 230 to avoid errors and delay generated by such on-die ECC engines, as discussed above. Of course, details of such a memory configuration are merely examples, and claimed subject matter is not so limited.

FIG. 3 is a schematic block diagram illustrating a system 300 and details of a memory configuration, according to an embodiment. A memory die 340, such as memory die 230 shown in FIG. 2 for example, may include an on-die command interpreter 350, an on-die ECC engine 360, a multiplexer 370, and a memory cell array 380 comprising, for example, an array of memory cells. On-die ECC engine 360, configured to correct read errors generated by memory cell array 380, may be switched on or off according to signals provided by on-die command interpreter 350. External to memory die 340, a host 310 may provide system level instructions via line 315, for example, to on-die command interpreter 350 that determine whether on-die command interpreter 350 is to provide such an on/off signal to on-die ECC engine 360 and multiplexer 370, according to one implementation. Such a host, for example, may comprise a memory controller or a processor, such as processor 110 shown in FIG. 1. In detail, on-die command interpreter 350 may provide an on/off control signal to multiplexer 370 via line 355, wherein such an on/off control signal may determine, at least in part, whether signals representative of read data from memory cell array 380 bypass on-die ECC engine 360 via line 375, for example. Line 355 may also provide such an on/off control signal to on-die ECC engine 360 to turn on or off on-die ECC engine 360. In one implementation, on-die ECC engine 360 may be switched off to avoid consuming power if on-die ECC engine 360 is to be bypassed. Of course, such a description of an on/off control signal is merely an example, and claimed subject matter is not so limited.

In one embodiment, there may be tradeoffs in using an on-die ECC engine versus using a system-level ECC engine, and vise versa. Such tradeoffs may involve performance, flexibility, and reliability of a system, such as system 300, for example. Performance may be determined by comparing probabilities of system level errors using either an internal ECC engine, an external ECC engine, or both an internal and external ECC engine, for example. In one implementation, whether an on-die ECC engine is faster than a system-level ECC engine may be tracked by host 310, which may also monitor a bit error rate (BER) from such various ECC engines. If either ECC engine is able to handle the BER that is present at a particular time, then such a host may determine that the slower ECC engine is to be turned off. Such a determination may be made during run-time, for example.

System 300, according to an embodiment, may also include a system-level ECC engine 320 that may be employed if, for example, on-die ECC engine 360 is switched off or otherwise disabled. Here, the term system-level indicates that such an ECC engine may be deployed external to memory die 340 and/or other larger portion of memory, such as memory module 140 and/or memory system 120 shown in FIG. 1, for example. Similar to a process involving subsystem-level ECC engine 220 mentioned above, system-level ECC engine 320 may be employed to provide system-level error correction across multiple memory die 340, for example. In one implementation, such system-level error correction may involve a system-level ECC engine 320 to perform error correction functions that would otherwise be carried out by multiple individual on-die ECC engines. In one embodiment, a system-level ECC engine may be more robust (e.g., capable of correcting more bits) than an on-die ECC engine. System-level error correction across multiple memory die may provide improved performance compared to error correction employed at a memory die level, such as by on-die ECC engine 360, for example. As discussed above, if system-level ECC engine 320 is employed, then it may be desirable to switch off or otherwise disable on-die ECC engine 360 residing on memory die 340 to avoid errors and delay generated by such an on-die ECC engine, and to avoid power consumption by on-die ECC engine 360. On the other hand, system-level ECC engine 320 may be switched off or otherwise disabled if, for example, on-die ECC engine 360 is selected to be employed. In another embodiment, however, both on-die ECC engine 360 and system-level ECC engine 320 may both be enabled to operate at the same time. A multiplexer 330 may receive a signal 335 that may determine, at least in part, whether signals representative of read data from memory die 340 bypass system-level ECC engine 320 via line 335, for example. Of course, details of such a system and memory configuration are merely examples, and claimed subject matter is not so limited.

FIG. 4 is a flow diagram illustrating a read/write process, according to an embodiment. Such a process may employ systems and/or memory system embodiments described above, though claimed subject matter is not so limited. At block 410, a read/write process to read/write to a portion of a memory system may be initiated, for example, by a system application that provides one or more read/write addresses to respectively identify one or more memory locations from where stored signals representative of information is to be read or where data is to be written. At block 420, signals representative of data may be read from/written to such memory locations. Signals representative of read/write data may include errors generated at the memory system from where such data is read or written to. Accordingly, an ECC engine may be employed to correct such errors. At block 430, a question, however, may remain as to which ECC engine to select for such an error correcting process; an on-die ECC engine or a system-level ECC engine. As discussed above, an answer to such a question may, at least in part, depend on which ECC engine may provide the best performance in terms of capability to correct errors, delay, and/or flexibility of applying such error correction. On-die ECC engine, at block 440, may, if not already, be disabled if it is determined not to use the on-die ECC engine. On the other hand, if a determination is made to employ the on-die ECC engine, then, at block 450, on-die ECC engine may, if not already, be enabled.

In one embodiment, a die-level ECC engine may be configured by a memory system during runtime, wherein software and/or executable code may determine, as in block 430, such configurations based, at least in part, on real-time system level information, for example. Such information may be gathered by a memory system and subsequently used to characterize memory system. For example, as memory die within such a system deteriorate, errors appear and may increase in number to where internal ECC engines may no longer be capable of correcting errors. In such a case, system-level software, for example, may determine that an external ECC engine is to be incorporated in order to deal with such an increased number of errors, and one or more internal ECC engines may then be eliminated. Such a determination, in one particular implementation, may be performed on-the-fly, though claimed subject matter is not so limited.

At block 460, a determination is made as to whether a system-level ECC engine is to be employed. Again, an answer to such a question may, at least in part, depend on which ECC engine or combination of engines may provide the best performance in terms of capability to correct errors, delay, and/or flexibility of applying such error correction. For example, some considerations regarding such performance may include code size (how large a block of memory may be corrected), number of bits that may be corrected in the code size, latency involved with error correction, error-correcting techniques used and types of errors that may be corrected (insertions, deletions, altered bits, etc). For example, an ECC engine presented with a 4K code word may be able to correct 3 bits in several nanoseconds, using the Reed Solomon or BCH techniques. System-level ECC engine, at block 470, may, if not already, be disabled if it is determined not to use a system-level ECC engine. On the other hand, if a determination is made to employ a system-level ECC engine, then, at block 480, system-level ECC engine may, if not already, be enabled. With the appropriate ECC engines either enabled or disabled, the read process initiated at block 410 may continue at block 490. Of course, details of such a read process are merely examples, and claimed subject matter is not so limited.

FIG. 5 is a schematic block diagram illustrating a computing system 500 and a memory system 510, according to an embodiment. A computing device 504 may be representative of any device, appliance, and/or machine that may be configurable to manage memory system 510. Memory system 510 may include a memory controller 515 and a memory 522. By way of example but not limitation, computing device 504 may include: one or more computing devices and/or platforms, such as, e.g., a desktop computer, a laptop computer, a workstation, a server device, or the like; one or more personal computing or communication devices or appliances, such as, e.g., a personal digital assistant, mobile communication device, or the like; a computing system and/or associated service provider capability, such as, e.g., a database or data storage service provider/system; and/or any combination thereof.

It is recognized that all or part of the various devices shown in system 500, and the processes and methods as further described herein, may be implemented using or otherwise including hardware, firmware, software, or any combination thereof. Thus, by way of example but not limitation, computing device 504 may include at least one processing unit 520 and system-level ECC engine 560 that are operatively coupled to memory 522 through a bus 540 and a host or memory controller 515. Processing unit 520 is representative of one or more circuits configurable to perform at least a portion of a data computing procedure or process. By way of example but not limitation, processing unit 520 may include one or more processors, controllers, microprocessors, microcontrollers, application specific integrated circuits, digital signal processors, programmable logic devices, field programmable gate arrays, and the like, or any combination thereof. Processing unit 520 may communicate with memory controller 515 to process memory-related operations, such as read, write, and/or erase, as well as memory partition processes discussed above, for example. Processing unit 520 may include an operating system configured to communicate with memory controller 515. Such an operating system may, for example, generate commands to be sent to memory controller 515 over bus 540. Such commands may include instructions to enable and/or disable on-die and/or system-level ECC engines, as described above, for example.

Memory 522 is representative of any data storage mechanism. Memory 522 may include, for example, a primary memory 524 and/or a secondary memory 526. In a particular embodiment, memory 522 may comprise memory that may be partitioned based at least in part on one or more attributes of the memory and/or a memory management process, as described above. Primary memory 524 may include, for example, a random access memory, read only memory, etc. While illustrated in this example as being separate from processing unit 520, it should be understood that all or part of primary memory 524 may be provided within or otherwise co-located/coupled with processing unit 520.

Secondary memory 526 may include, for example, the same or similar type of memory as primary memory and/or one or more data storage devices or systems, such as, for example, a disk drive, an optical disc drive, a tape drive, and/or a solid state memory drive, which may comprise multiple memory die that individually include an on-die ECC engine (not shown in FIG. 5), for example. In certain implementations, secondary memory 526 may be operatively receptive of, or otherwise configurable to couple to, a computer-readable medium 528. Computer-readable medium 528 may include, for example, any medium that can carry and/or make accessible data, code, and/or instructions for one or more of the devices in system 500.

Computing device 504 may include, for example, an input/output 532. Input/output 532 is representative of one or more devices or features that may be configurable to accept or otherwise introduce human and/or machine inputs, and/or one or more devices or features that may be configurable to deliver or otherwise provide for human and/or machine outputs. By way of example but not limitation, input/output device 532 may include an operatively configured display, speaker, keyboard, mouse, trackball, touch screen, data port, etc.

In the above detailed description, numerous specific details are set forth to provide a thorough understanding of claimed subject matter. However, it will be understood by those skilled in the art that claimed subject matter may be practiced without these specific details. In other instances, methods, apparatuses, or systems that would be known by one of ordinary skill have not been described in detail so as not to obscure claimed subject matter.

Some portions of the detailed description above are presented in terms of algorithms or symbolic representations of operations on binary digital signals stored within a memory of a specific apparatus or special purpose computing device or platform. In the context of this particular specification, the term specific apparatus or the like includes a general purpose computer once it is programmed to perform particular operations pursuant to instructions from program software. Algorithmic descriptions or symbolic representations are examples of techniques used by those of ordinary skill in the signal processing or related arts to convey the substance of their work to others skilled in the art. An algorithm is here, and generally, is considered to be a self-consistent sequence of operations or similar signal processing leading to a desired result. In this context, operations or processing involve physical manipulation of physical quantities. Typically, although not necessarily, such quantities may take the form of electrical or magnetic signals capable of being stored, transferred, combined, compared or otherwise manipulated. It has proven convenient at times, principally for reasons of common usage, to refer to such signals as bits, data, values, elements, symbols, characters, terms, numbers, numerals, or the like. It should be understood, however, that all of these or similar terms are to be associated with appropriate physical quantities and are merely convenient labels. Unless specifically stated otherwise, as apparent from the following discussion, it is appreciated that throughout this specification discussions utilizing terms such as “processing,” “computing,” “calculating,” “determining” or the like refer to actions or processes of a specific apparatus, such as a special purpose computer or a similar special purpose electronic computing device. In the context of this specification, therefore, a special purpose computer or a similar special purpose electronic computing device is capable of manipulating or transforming signals, typically represented as physical electronic or magnetic quantities within memories, registers, or other information storage devices, transmission devices, or display devices of the special purpose computer or similar special purpose electronic computing device.

The terms, “and,” “and/or,” and “or” as used herein may include a variety of meanings that will depend at least in part upon the context in which it is used. Typically, “and/or” as well as “or” if used to associate a list, such as A, B or C, is intended to mean A, B, and C, here used in the inclusive sense, as well as A, B or C, here used in the exclusive sense. Reference throughout this specification to “one embodiment” or “an embodiment” means that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment of claimed subject matter. Thus, the appearances of the phrase “in one embodiment” or “an embodiment” in various places throughout this specification are not necessarily all referring to the same embodiment. Furthermore, the particular features, structures, or characteristics may be combined in one or more embodiments. Embodiments described herein may include machines, devices, engines, or apparatuses that operate using digital signals. Such signals may comprise electronic signals, optical signals, electromagnetic signals, or any form of energy that provides information between locations.

While there has been illustrated and described what are presently considered to be example embodiments, it will be understood by those skilled in the art that various other modifications may be made, and equivalents may be substituted, without departing from claimed subject matter. Additionally, many modifications may be made to adapt a particular situation to the teachings of claimed subject matter without departing from the central concept described herein. Therefore, it is intended that claimed subject matter not be limited to the particular embodiments disclosed, but that such claimed subject matter may also include all embodiments falling within the scope of the appended claims, and equivalents thereof. 

What is claimed is:
 1. A method of operating a memory device comprising a memory array on a memory die, comprising: providing the memory die, the memory die comprising: a memory array; and an on-die error correction coding engine; providing an error correction coding engine located external to the memory die, wherein the error correction coding engine located external to the memory die is configured to correct errors in information read from the memory array; reading a first information stored in the memory array; detecting a first error in the first read information; using the on-die error correction coding engine for correcting the first error; reading a second information stored in the memory array; detecting a second error in the second read information; and subsequently correcting the second error using the error correction coding engine located external to the memory die.
 2. The method of claim 1, further comprising bypassing the on-die error correction coding engine prior to correcting the second error.
 3. The method of claim 2, further comprising determining a number of errors generated by the memory die and comparing the number to an error threshold value, wherein the bypassing is performed in response to the number of errors exceeding the error threshold value.
 4. The method of claim 1, further comprising turning off the on-die error correction coding engine prior to correcting the second error.
 5. The method of claim 1, further comprising disabling the on-die error correction coding engine during a read or write operation prior to correcting the second error.
 6. The method of claim 1, further comprising run-time tracking of an error correction performance of the on-die error correction coding engine.
 7. The method of claim 1, further comprising providing a signal to a multiplexer to bypass the on-die error correction coding engine.
 8. A memory system, comprising: a memory die comprising a memory array and an on-die error correction coding engine; and an error correction coding engine located externally from the memory die, wherein both the on-die error correction coding engine and the error correction coding engine located externally from the memory die are configured to correct errors in information read from the memory array.
 9. The system of claim 8, further comprising an on-die command interpreter configured to provide to a multiplexer a signal indicating bypassing of the on-die error correction coding engine.
 10. The system of claim 8, wherein the memory array comprises phase change memory.
 11. The system of claim 8, further comprising a memory controller configured to disable the on-die error correction coding engine if the error correction coding engine located externally from the memory die is used to correct the errors.
 12. The system of claim 8, further comprising a memory controller configured to disable the on-die error correction coding engine in response to a number of errors generated by the memory die exceeding a threshold error value.
 13. The system of claim 8, further comprising a plurality of additional memory dies, wherein each individual die of the plurality of additional memory dies comprises a corresponding on-die error correction coding engine.
 14. The system of claim 13, wherein the error correction coding engine located externally from the memory die is further configured to correct errors generated by each individual die of the plurality of additional memory dies.
 15. The system of claim 14, further comprising a memory controller configured to bypass the corresponding on-die error correction coding engine of the plurality of additional memory dies if the error correction coding engine located externally from the memory die is used to correct errors generated by each individual die of the plurality of additional memory dies.
 16. A system, comprising: a memory array on a memory die; an on-die error correction coding engine and an error correction coding engine located externally from the memory die, wherein both the on-die error correction coding engine and the error correction coding engine located externally from the memory die are configured to correct errors in information read from the memory array; and a processor for initiating a command to a memory controller for accessing the memory array.
 17. The system of claim 16, wherein the error correction coding engine located externally from the memory die is configured to have a greater error correction capacity than the on-die error correction coding engine.
 18. The system of claim 16, wherein the memory controller is configured to disable the on-die error correction coding engine if the error correction coding engine located externally from the memory die is used to correct the errors.
 19. The system of claim 18, wherein the memory controller is configured to disable the on-die error correction coding engine during a runtime of the system.
 20. The system of claim 16, wherein the memory controller is configured to disable the on-die error correction coding engine in response to a number of errors generated by the memory die exceeding a threshold error value.
 21. A method of operating a memory device comprising a memory array on a memory die, comprising: providing the memory die, the memory die comprising: a memory array; and an on-die error correction coding engine; providing an error correction coding engine located external to the memory die, wherein the error correction coding engine located external to the memory die is configured to correct errors in information read from the memory array; reading a first information stored in the memory array; detecting a first error in the first read information; correcting the first error; and performing run-time tracking of an error correction performance of the on-die error correction coding engine.
 22. A method of operating a memory device comprising a memory array on a memory die, comprising: providing the memory die, the memory die comprising: a memory array; and an on-die error correction coding engine; providing an error correction coding engine located external to the memory die, wherein the error correction coding engine located external to the memory die is configured to correct errors in information read from the memory array; reading a first information stored in the memory array; detecting a first error in the first read information; correcting the first error; and providing a signal to a multiplexer to bypass the on-die error correction coding engine. 